 1.Kafka高级特性解析之稳定性中的幂等性
   
   Kafka在引入幂等性之前，Producer向Broker发送消息，然后Broker将消息追加到消息流中后给Producer返回
Ack信号值。实现流程如下：
  生产中，会出现各种不确定的因素，比如在Producer在发送给Broker的时候出现网络异常。比如以下这种异常情
况的出现：
  上图这种情况，当Producer第一次发送消息给Broker时，Broker将消息(x2,y2)追加到了消息流中，但是在返回
Ack信号给Producer时失败了（比如网络异常） 。此时，Producer端触发重试机制，将消息(x2,y2)重新发送给
Broker，Broker接收到消息后，再次将该消息追加到消息流中，然后成功返回Ack信号给Producer。这样下来，消息
流中就被重复追加了两条相同的(x2,y2)的消息。
  幂等性
  保证在消息重发的时候，消费者不会重复处理。即使在消费者收到重复消息的时候，重复处理，也要保证最终结
果的一致性。
  所谓幂等性，数学概念就是： f(f(x)) = f(x) 。f函数表示对消息的处理。
  比如，银行转账，如果失败，需要重试。不管重试多少次，都要保证最终结果一定是一致的。
  幂等性实现
  添加唯一ID，类似于数据库的主键，用于唯一标记一个消息。
  Kafka为了实现幂等性，它在底层设计架构中引入了ProducerID和SequenceNumber。
       ProducerID：在每个新的Producer初始化时，会被分配一个唯一的ProducerID，这个ProducerID对客户端
使用者是不可见的。
       SequenceNumber：对于每个ProducerID，Producer发送数据的每个Topic和Partition都对应一个从0开始
单调递增的SequenceNumber值。
  同样，这是一种理想状态下的发送流程。实际情况下，会有很多不确定的因素，比如Broker在发送Ack信号给
Producer时出现网络异常，导致发送失败。异常情况如下图所示： 
  当Producer发送消息(x2,y2)给Broker时，Broker接收到消息并将其追加到消息流中。此时，Broker返回Ack信号
给Producer时，发生异常导致Producer接收Ack信号失败。对于Producer来说，会触发重试机制，将消息(x2,y2)再次
发送，但是，由于引入了幂等性，在每条消息中附带了PID（ProducerID）和SequenceNumber。相同的PID和
SequenceNumber发送给Broker，而之前Broker缓存过之前发送的相同的消息，那么在消息流中的消息就只有一条
(x2,y2)，不会出现重复发送的情况。
  客户端在生成Producer时，会实例化如下代码：
  // 实例化一个Producer对象
  Producer<String, String> producer = new KafkaProducer<>(props);
  在org.apache.kafka.clients.producer.internals.Sender类中，在run()中有⼀个maybeWaitForPid()方法，用来
生成一个ProducerID，实现代码如下：
  private void maybeWaitForPid() {
        if (transactionState == null)
              return;
        while (!transactionState.hasPid()) {
          try {
              Node node = awaitLeastLoadedNodeReady(requestTimeout);
              if (node != null) {
                  ClientResponse response = sendAndAwaitInitPidRequest(node);
                  if (response.hasResponse() && (response.responseBody() instanceof
  InitPidResponse)) {
                      InitPidResponse initPidResponse = (InitPidResponse)
response.responseBody();
                      transactionState.setPidAndEpoch(initPidResponse.producerId(),
initPidResponse.epoch());
                    } else {
                       log.error("Received an unexpected response type for an
InitPidRequest from {}. " +
                            "We will back off and try again.", node);
                    }
                } else {
                    log.debug("Could not find an available broker to send
InitPidRequest to. " +
                           "We will back off and try again.");
               }
           } catch (Exception e) {
               log.warn("Received an exception while trying to get a pid. Will back
off and retry.", e);
           }
            log.trace("Retry InitPidRequest in {}ms.", retryBackoffMs);
            time.sleep(retryBackoffMs);
            metadata.requestUpdate();
        }
  }
 2.事务操作
   
   在Kafka事务中，一个原子性操作，根据操作类型可以分为3种情况。情况如下：
   1).只有Producer生产消息，这种场景需要事务的介入；
   2).消费消息和生产消息并存，比如Consumer&Producer模式，这种场景是一般Kafka项目中比较常见的模式，
需要事务介入；
   3).只有Consumer消费消息，这种操作在实际项目中意义不大，和手动Commit Offsets的结果一样，而且这种
场景不是事务的引入目的。
// 初始化事务，需要注意确保transation.id属性被分配
void initTransactions();
// 开启事务
void beginTransaction() throws ProducerFencedException;
// 为Consumer提供的在事务内Commit Offsets的操作
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets,
                              String consumerGroupId) throws ProducerFencedException;
// 提交事务
void commitTransaction() throws ProducerFencedException;
// 放弃事务，类似于回滚事务的操作
void abortTransaction() throws ProducerFencedException;
  案例1：单个Producer，使用事务保证消息的仅一次发送：
package com.lagou.kafka.demo.producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.HashMap;
import java.util.Map;

public class MyTranscactionalProducer {

    public static void main(String[] args) {
        Map<String, Object> configs = new HashMap<String, Object>();
        configs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux121:9092");
        configs.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configs.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

        // 提供生产者client.id
        configs.put(ProducerConfig.CLIENT_ID_CONFIG, "tx_producer");
        // 设置事务ID
        configs.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "my_tx_id_1");
        // 需要ISR全体确认消息
        configs.put(ProducerConfig.ACKS_CONFIG, "all");
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(configs);

        // 初始化事务
        producer.initTransactions();
        try {
            // 开启事务
            producer.beginTransaction();
            // 发送事务消息
            producer.send(new ProducerRecord<>("tp_tx_01", "txkey1", "tx_msg_4"));
            producer.send(new ProducerRecord<>("tp_tx_01", "txkey1", "tx_msg_5"));
            producer.send(new ProducerRecord<>("tp_tx_01", "txkey1", "tx_msg_6"));
            int i = 1 / 0;
            // 提交事务
            producer.commitTransaction();
        } catch (Exception e) {
            e.printStackTrace();
           // 事务回滚
            producer.abortTransaction();
        } finally {
            // 关闭生产者
            producer.close();
        }
    }
}

  案例2：在消费-转换-生产模式，使用事务保证仅一次发送。
package com.lagou.kafka.demo;

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class MyTransactional {

    public static KafkaProducer<String, String> getProducer() {
        Map<String, Object> configs = new HashMap<>();
        configs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux121:9092");
        configs.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configs.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

        // 设置client.id
        configs.put(ProducerConfig.CLIENT_ID_CONFIG, "tx_producer_01");
        // 设置事务id
        configs.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "tx_id_02");
        // 需要所有的ISR副本确认
        configs.put(ProducerConfig.ACKS_CONFIG, "all");
        // 启用幂等性
        configs.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);

        KafkaProducer<String, String> producer = new KafkaProducer<>(configs);
        return producer;
    }
    public static KafkaConsumer<String, String> getConsumer(String consumerGroupId) {
        Map<String, Object> configs = new HashMap<>();
        configs.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux121:9092");
        configs.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        configs.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        // 设置消费组ID
        configs.put(ConsumerConfig.GROUP_ID_CONFIG, "consumer_grp_02");
        // 不启用消费者偏移量的自动确认
        configs.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        configs.put(ConsumerConfig.CLIENT_ID_CONFIG, "consumer_client_02");
        configs.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        // 只读取已提交对的消息
//        configs.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG, "read_committed");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(configs);
        return consumer;

    }
    public static void main(String[] args) {

        String  consumerGroupId = "consumer_grp_id_101";
        KafkaProducer<String, String> producer = getProducer();
        KafkaConsumer<String, String> consumer = getConsumer(consumerGroupId);

        // 事务的初始化
        producer.initTransactions();
        // 订阅主题
        consumer.subscribe(Collections.singleton("tp_tx_01"));
        final ConsumerRecords<String, String> records = consumer.poll(1_000);

        // 开启事务
        producer.beginTransaction();
        try {

            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record);
                producer.send(new ProducerRecord<String, String>("tp_tx_out_01", record.key(), record.value()));

                offsets.put(
                        new TopicPartition(record.topic(),record.partition()),
                        new OffsetAndMetadata(record.offset() + 1)
                ); // 偏移量表示下一条要消费的消息

                // 将消息的偏移量提交作为事务的一部分，随事务提交和回滚(不提交消费偏移量)
                producer.sendOffsetsToTransaction(offsets, consumerGroupId);

//                int i = 1 / 0;
                // 提交事务
                producer.commitTransaction();
            }
        }  catch (Exception e) {
            e.printStackTrace();
            // 回滚事务
            producer.abortTransaction();
        } finally {
            producer.close();
            consumer.close();
        }
    }
}
